
module.exports = {
    /**
     * 添加数据：返回添加的数据对象
     * @params {*} model 数据模型
     * @params {*} params 参数，新增的数据对象
     * @params {*} callback 回调函数
     * @returns 
     */
    add:async (model,params,callback)=>{
        return new Promise(async(resolve,reject) =>{
            const result = await new model(params).save()
            resolve(result)
            callback && callback(result)
        })
    },

    /**
     * 批量添加数据
     * @param {*} model 数据模型
     * @param {*} params 对象数组
     * @returns 
     */
    insertMany:async (model,params) =>{
        return new Promise(async (resolve,reject) =>{
            model.insertMany(params)
            .then(res =>{
                resolve(res)
            })
            .catch(err =>{
                resolve(err)
            })
        })
    },

    deleteOne:async (model,params,callback)=>{
        return new Promise(async(resolve,reject) =>{
            model.deleteOne(params)
            .then(data =>{
                resolve(data)
                callback && callback(data)
            })
        })
    },

    /**
     * 删除数据，可以删除多条
     * @param {*} model 
     * @param {*} params 
     * @param {*} callback 
     * @returns 
     */
    remove:async (model,params,callback)=>{
        return new Promise(async(resolve,reject) =>{
            model.deleteMany(params)
            .then(data =>{
                resolve(data)
                callback && callback(data)
            }).catch(err =>{
                resolve(false)
            })
        })
    },

    /**
     * 根据id编辑数据：返回被编辑的对象
     * @params {*} model 数据模型
     * @params {*} id 数据ID，唯一标示
     * @params {*} params 需要更新的数据对象
     * @params {*} callback 回调函数
     * @returns 
     */
    edit:async (model,id,params,callback)=>{
        return new Promise(async(resolve,reject) =>{
            model.findByIdAndUpdate(id,params)
            .then(data =>{
                resolve(data)
                callback && callback(data)
            }) 
        })
    },

    /**
     * 更新数据（批量更新）
     * @params {*} model 数据模型
     * @param {*} conditions 更新满足此条件的数据对象
     * @param {*} params // 需要更新的数据对象
     * @returns 
     */
    update:(model,conditions,params,callback)=>{
        return new Promise(async(resolve,reject) =>{
            model.updateMany(conditions,params)
            .then(data =>{
                resolve(data)
                callback && callback(data)
            }) 
        })
    },

    /**
     * 查询一条数据
     * @param {*} model 数据模型
     * @param {*} params 参数对象
     * @param {*} populate populate连接字段名字符串
     * @returns 
     */
    findOne:async(model,params,populate) =>{
        return new Promise(async(resolve,reject) =>{
            model.findOne(params).populate(populate?populate:null)
            .then(data =>{
                resolve(data)
                //callback && callback(data)
            })
        })
    },

    /**
     * 查询数据：返回数组
     * @param {*} model 数据模型
     * @param {*} options 筛选条件、排序、字段填充、分页等参数
     * @param {*} callback 回调函数
     * @returns 
     * options的参数形式如下：
     * options:{
       params:{}  筛选条件
       sort:{createTime:-1}  排序
       populate:'' || []  字段填充
       page:{pageSize:10,pageIndex:1}
    }
    */
    find:async (model,options,callback) =>{
        return new Promise(async(resolve,reject) =>{
            let pageSize=null,pageIndex=null,skip=null,total=0
            if(options && options.page && options.page.pageSize){
                pageSize = options.page.pageSize
            }
            if(options && options.page && options.page.pageIndex){
                pageIndex = options.page.pageIndex
            }
            if(pageSize && pageIndex){
                skip=(pageIndex-1)*pageSize
                total = await model.countDocuments((options && options.params)?options.params:null)
            }

            model.find((options && options.params)?options.params:null)
            .populate((options && options.populate)?options.populate:null)
            .limit(pageSize)   // （限制显示文档个数）每页显示条数，
            .skip(skip) //（跳过文档个数）即显示第几页的数据
            .sort((options && options.sort)?options.sort:null)
            .then(data =>{
                const obj = {
                    data,
                    pageSize,
                    pageIndex,
                    total
                }
                resolve(obj)
                callback && callback(obj)
            })
            .catch(err =>{
                resolve(err)
            })
        })
    },

    /**
     * 查询数据
     * @param {*} model 数据模型
     * @param {*} params 原生aggregate参数，对象数组形式
     * @param {*} page 分页数据，对象{pageSize,pageIndex}
     * @param {*} sort 排序，对象
     * @param {*} callback 回调函数
     * @returns 
     */
    aggregate: async (model,params,page,sort,callback) =>{
        return new Promise(async(resolve,reject) =>{
            let pageSize=null,pageIndex=null,skip=0,total=null
            if(page && page.pageSize){
                pageSize = page.pageSize
            }
            if(page && page.pageIndex){
                pageIndex = page.pageIndex
            }
            if(pageSize && pageIndex){
                skip=(pageIndex-1)*pageSize
                const countData = await model.aggregate([
                    ...params,
                    {$count: "total"}
                ])
                if(countData.length>0){
                    total = countData[0].total
                }
                params.push({$sort:sort})
                params.push({$skip:skip})
                params.push({$limit:pageSize})
            }
            
            model.aggregate(params)
            //.sort(sort || {createTime:1})
            //.skip(0) //（跳过文档个数）即显示第几页的数据
            //.limit(0)   // （限制显示文档个数）每页显示条数，
            .then(data =>{
                const obj = {
                    data,
                    pageSize,
                    pageIndex,
                    total
                }
                resolve(obj)
                callback && callback(obj)
            })
            .catch(err =>{
                resolve(err)
            })
        })
    },

    /**
     * 通过id查询数据：返回对象
     * @params {*} model 数据模型
     * @params {*} id 数据id，唯一标示
     * @params {*} callback 回调函数
     * @returns 
     */
    findById:async (model,id,callback) =>{
        return new Promise(async(resolve,reject) =>{
            model.findById(id)
            .then(data =>{
                resolve(data)
                callback && callback(data)
            })
        })
    },


}
